﻿using UnityEngine;
using UnityEngine.EventSystems;
using System.Collections;
using System.Collections.Generic;
using com.gzc.zgxq.game;
using System;

namespace SocialPoint.Examples.MVC {
    /// <summary>
    /// 挂在下标检查球上的落子点脚本，判断棋盘上的某个点是否有棋子
    /// </summary>
    public class PointBehaviour : MonoBehaviour, IPointerClickHandler {

        /// <summary>
        /// 在10-9二维数的下标是第几行
        /// </summary>
        public byte m_i { get; set; }
        /// <summary>
        /// 在10-9二维数的下标是第几列
        /// </summary>
        public byte m_j { get; set; }

        /// <summary>
        /// 在256（16*16）1维数的下标
        /// </summary>
        public int Index256 { get; set; }

        /// <summary>
        /// 在256（16*16）二维数的下标是第几行
        /// </summary>
        public byte m_row { get; set; }
        /// <summary>
        /// 在256（16*16）二维数的下标是第几列
        /// </summary>
        public byte m_column { get; set; }


        private GameObject m_selfGameObject;
        private EventSystem m_EventSystem;

        #region U3D API

        void Awake ( ) {
            InitValue( );
        }

        #endregion U3D API

        #region 实现IPointerClickHandler接口

        static int clickCount = 0;
        static GameObject s_selectedChess = null;       

        public void OnPointerClick (PointerEventData eventData) {
            m_EventSystem.SetSelectedGameObject(m_selfGameObject);
            Debuger.Log(string.Format("点击的Index球是{0}, 点的哪个棋子={1}", Index256, ChessMoveSearchEnginMain.s_chessBordArr[Index256]));

            PlayerMoveChess( );
        }
        // 先直接在该类里写，把功能实现后，再用ACTION 事件把逻辑注册到CTRL来驱动完成

        void IsPlayerWin ( ) {
            // 如果玩家赢了
            if (ChessMoveSearchEnginMain.IsMate( )) {
                Debuger.Log("玩家赢了");
            } else {
                Debuger.LogError("玩家没赢，AI走棋");

                GameController.instance.m_ai.AiOnceMove( );
            }
        }

        void PlayerMoveChess ( ) {
            //第1次点击，点击格子
            //判断该格子有没有棋子
            if (0 != ChessMoveSearchEnginMain.s_chessBordArr[Index256] && 0 == clickCount) {
                PlayerSelectedChess( );

                //第2次点击，点击了别的格子
            } else if (1 == clickCount) {
                // 走一步棋的走法
                int move = IndexCtrlBehaviour.s_xzgz + ((m_i + 3) * 16 + m_j + 3) * 256;
                int sqSrc = ChessMoveSearchEnginUtil.SRC(move);	// 得到起始位置的数组下标
                // 下棋终点的格子在256数组的下标     
                int sqDst = ChessMoveSearchEnginUtil.DST(move);
                // 通过256数组的下标值，得到下棋终点是哪颗棋子
                int playerCaptured = ChessMoveSearchEnginMain.s_chessBordArr[sqDst];
                // 通过256数组的下标值，得到下棋起点是哪颗棋子
                int pc=ChessMoveSearchEnginMain.s_chessBordArr[sqSrc];

                Debuger.LogWarning("sqDst = " + sqDst + ", 得到目的格子的棋子playerCaptured = " + playerCaptured + ", move = " + move);

                // 目的格子没棋子
                if (0 == playerCaptured) {
                    LegalMoveAction(move, ( ) => {  //这样匿名函数每次调用都new了个对象，要优化
                        //走棋
                        Debuger.Log(string.Format("走棋 move={0}", move));
                        //数据走棋
                        Check(move, sqSrc, sqDst, null);
                    });
                } else { // 目的格子有棋子
                    //目的格子有棋子，是黑方的棋子，吃子
                    if (playerCaptured > 14) {
                        LegalMoveAction(move, ( ) => {
                            //吃子
                            Debuger.Log(string.Format("吃子 move={0}", move));
                            //数据吃子                          
                            Check(move, sqSrc, sqDst, ( ) => {
                                //走棋终点格子上要吃的棋子
                                ChessViewPresenter.instance.GetHashIndexChess(sqDst).SetActive(false);      
                            });
                        });    
                    } else { // 再次点的又是己方棋子
                        Debuger.Log(string.Format("再次点的又是己方棋子"));
                        PlayerSelectedChess( );
                    }           
                }
            } else {    // 点的格子没棋子                    
                ResetClickCount( );
            }
            //有己方棋子则不走，选中新的己方棋子
            //有敌方棋子或无子则判断下棋是否符合走棋规则
            //符合则走棋，有子则吃子
        }

        //走这步棋的时候有没有被将军，没有则可以走
        void Check (int move, int sqSrc, int sqDst, Action viewCapturedAction) {
            //数据走棋          
            // 如果没有被将军
            if (ChessMoveSearchEnginMain.MakeMove(move, 0)) {
                //VIEW吃子               
                Util.CallAction(viewCapturedAction);

                //VIEW: GAME OBJ 走棋                            
                //设置VIEW                             
                PlayerMoveChessSetView(sqSrc, sqDst);
            } else {
                Debuger.Log(string.Format("你被将军了，不能走这一步棋"));
            }
        }

        private void PlayerMoveChessSetView (int sqSrc, int sqDst) {
            SetViewChess(sqSrc, sqDst, PlayerMoveChess(sqDst));
            ResetClickCount( );
            IsPlayerWin( );
        }

        void ResetClickCount ( ) {
            clickCount = 0;
        }

        // 合法走棋操作
        void LegalMoveAction (int move, Action action) {
            if (ChessMoveSearchEnginMain.LegalMove(move)) {
                Util.CallAction(action);
            } else {
                Debuger.LogError(string.Format("走棋不合法 move={0}", move));
                // 非法操作Action
            }
        }

        public void SetViewChess (int sqSrc, int sqDst, GameObject playerMoveChess) {
            //吃子后，该格子上的棋子
            ChessViewPresenter.instance.SetHashIndexCheess(sqDst, playerMoveChess);
            //走棋的起点格子设置为没棋子
            ChessViewPresenter.instance.SetHashIndexCheess(sqSrc, null);
        }

        void PlayerSelectedChess ( ) {
            //是己方棋子则选中该棋子-----》棋子变红
            if (ChessMoveSearchEnginMain.s_chessBordArr[Index256] >= 8 && ChessMoveSearchEnginMain.s_chessBordArr[Index256] <= 14) {
                ChessViewPresenter.SelectedChess = ChessViewPresenter.instance.GetHashIndexChess(Index256);
                if (null != ChessViewPresenter.SelectedChess) {
                    Debuger.Log(string.Format("选中棋子{0}", ChessViewPresenter.SelectedChess.name));

                    // 选中的棋子的格子是这么多，也就是其在256数组的下标
                    IndexCtrlBehaviour.s_xzgz = (m_i + 3) * 16 + m_j + 3;
                    //IndexCtrlBehaviour.s_xzgz = xzgz;
                    Debuger.LogWarning("选中棋子" + this.name + "原始位置为" + this.name + "位置上！其在的256数组的下标为" + IndexCtrlBehaviour.s_xzgz);

                    if (0 == clickCount) {
                        clickCount++;
                    }
                }
            }
        }

        public GameObject PlayerMoveChess (int sqDst) {
            //走棋起点格子上的棋子
            GameObject playerMoveChess = ChessViewPresenter.instance.GetHashIndexChess(IndexCtrlBehaviour.s_xzgz);
            //走棋终点格子坐标                        
            Vector3 v3Target = IndexCtrlBehaviour.instance.getIndexSphereGo(sqDst).transform.localPosition;
            float moveTime = 1F;
            //ITWEEN移动
            TweenUtil.MoveTo(playerMoveChess, v3Target, moveTime);
            StartCoroutine(DelayToInvokeUtil.DelayToInvokeDo(( ) => {
                // 移动过去后重置颜色
                ChessViewPresenter.ResetSelectedFX( );
            }, moveTime));

            return playerMoveChess;
        }

        #endregion 实现IPointerClickHandler接口

        void InitValue ( ) {     
            m_selfGameObject = this.gameObject;
            m_EventSystem = EventSystem.current;     
        }

        /// <summary>
        /// 16*16的2维数组下标转换为256的1维数组中的下标
        /// </summary>
        /// <returns></returns>
        public int toIndex256 ( ) {
            // 二维数组 a[INDEX1][INDEX2] 转换成一维数组b[INDEX1*INDEX2]，则a[i][j] 对应一维数组的索引 b[INDEX2*i+j]
            // 只与列数有关，与行数无关。
            int index256 = 16 * m_row + m_column;
            return index256;
        }


    }
}
